NumPy-இன் ஆற்றலை வெளிக்கொணர்தல்: ஒலிபரப்பு மற்றும் வரிசை வடிவ கையாளுதலில் ஒரு ஆழமான ஆய்வு

பைத்தானில் உயர் செயல்திறன் கொண்ட எண் கணக்கீட்டு உலகத்திற்கு வரவேற்கிறோம்! நீங்கள் தரவு அறிவியல், இயந்திரக் கற்றல், அறிவியல் ஆராய்ச்சி அல்லது நிதி பகுப்பாய்வில் ஈடுபட்டிருந்தால், நீங்கள் NumPy-ஐ நிச்சயம் சந்தித்திருப்பீர்கள். இது பைதான் அறிவியல் கணக்கீட்டு சுற்றுச்சூழல் அமைப்பின் அடித்தளமாகும், இது ஒரு சக்திவாய்ந்த N-பரிமாண வரிசைப் பொருளையும் அதைக் கையாள பல அதிநவீன செயல்பாடுகளையும் வழங்குகிறது.

புதியவர்களுக்கும், இடைநிலை பயனர்களுக்கும் கூட பொதுவான தடைகளில் ஒன்று, நிலையான பைத்தானின் பாரம்பரிய, சுழற்சி அடிப்படையிலான சிந்தனையில் இருந்து திறமையான NumPy குறியீட்டிற்குத் தேவையான வெக்டராக்கப்பட்ட, வரிசை சார்ந்த சிந்தனைக்கு மாறுவதுதான். இந்த முன்னுதாரண மாற்றத்தின் மையத்தில் ஒரு சக்திவாய்ந்த, ஆனால் பெரும்பாலும் தவறாகப் புரிந்துகொள்ளப்பட்ட, பொறிமுறை உள்ளது: ஒலிபரப்பு (Broadcasting). இது NumPy ஆனது வெவ்வேறு வடிவங்கள் மற்றும் அளவுகளில் உள்ள வரிசைகளில் அர்த்தமுள்ள செயல்பாடுகளைச் செய்ய அனுமதிக்கும் "மாயாஜாலம்" ஆகும், இவை அனைத்தும் வெளிப்படையான பைதான் சுழற்சிகளின் செயல்திறன் இழப்பு இல்லாமல் நிகழ்கிறது.

இந்த விரிவான வழிகாட்டி உலகளாவிய டெவலப்பர்கள், தரவு விஞ்ஞானிகள் மற்றும் ஆய்வாளர்களுக்காக வடிவமைக்கப்பட்டுள்ளது. ஒலிபரப்பை அடிப்படையிலிருந்து விளக்குவோம், அதன் கடுமையான விதிகளை ஆராய்வோம், மேலும் அதன் முழு திறனையும் பயன்படுத்த வரிசை வடிவ கையாளுதலை எவ்வாறு கற்றுத் தேர்ந்தெடுப்பது என்பதைக் காட்டுவோம். இதன் முடிவில், ஒலிபரப்பு *என்றால் என்ன* என்பதை மட்டுமல்லாமல், ஏன் சுத்தமான, திறமையான மற்றும் தொழில்முறை NumPy குறியீட்டை எழுத அது *முக்கியமானது* என்பதையும் நீங்கள் புரிந்துகொள்வீர்கள்.

NumPy ஒலிபரப்பு என்றால் என்ன? மையக் கருத்து

அதன் மையத்தில், ஒலிபரப்பு என்பது எண்கணித செயல்பாடுகளின் போது வெவ்வேறு வடிவங்களைக் கொண்ட வரிசைகளை NumPy எவ்வாறு கையாள்கிறது என்பதை விவரிக்கும் விதிகளின் தொகுப்பாகும். ஒரு பிழையை எழுப்புவதற்குப் பதிலாக, சிறிய வரிசையை பெரிய வரிசையின் வடிவத்துடன் பொருந்துமாறு மெய்நிகராக "நீட்டிப்பதன்" மூலம் செயல்பாட்டைச் செய்ய ஒரு இணக்கமான வழியைக் கண்டறிய முயற்சிக்கிறது.

சிக்கல்: பொருந்தாத வரிசைகளில் செயல்பாடுகள்

உங்களிடம் 3x3 அணி (உதாரணமாக, ஒரு சிறிய படத்தின் பிக்சல் மதிப்புகளைக் குறிக்கும்) உள்ளது என்று கற்பனை செய்து பாருங்கள், மேலும் ஒவ்வொரு பிக்சலின் பிரகாசத்தையும் 10 என்ற மதிப்பில் அதிகரிக்க விரும்புகிறீர்கள். நிலையான பைத்தானில், பட்டியல்களின் பட்டியல்களைப் பயன்படுத்தி, நீங்கள் ஒரு உள்ளமைக்கப்பட்ட சுழற்சியை எழுதலாம்:

பைதான் சுழற்சி அணுகுமுறை (மெதுவான வழி)

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] result = [[0, 0, 0], [0, 0, 0], [0, 0, 0]] for i in range(len(matrix)): for j in range(len(matrix[0])): result[i][j] = matrix[i][j] + 10 # முடிவு [[11, 12, 13], [14, 15, 16], [17, 18, 19]] ஆக இருக்கும்

இது வேலை செய்கிறது, ஆனால் இது வார்த்தை ஜாலமாக உள்ளது, மேலும் முக்கியமாக, பெரிய வரிசைகளுக்கு நம்பமுடியாத அளவிற்கு திறமையற்றது. பைதான் மொழிபெயர்ப்பாளருக்கு சுழற்சியின் ஒவ்வொரு மறு செய்கைக்கும் அதிக overhead உள்ளது. இந்த தேக்கநிலையை அகற்ற NumPy வடிவமைக்கப்பட்டுள்ளது.

தீர்வு: ஒலிபரப்பின் மாயாஜாலம்

NumPy உடன், அதே செயல்பாடு எளிமை மற்றும் வேகத்தின் மாதிரியாக மாறுகிறது:

NumPy ஒலிபரப்பு அணுகுமுறை (வேகமான வழி)

import numpy as np matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) result = matrix + 10 # முடிவு இவ்வாறாக இருக்கும்: # array([[11, 12, 13], # [14, 15, 16], # [17, 18, 19]])

இது எப்படி வேலை செய்தது? `matrix` ஆனது `(3, 3)` வடிவத்தைக் கொண்டுள்ளது, அதேசமயம் scalar `10` ஆனது `()` வடிவத்தைக் கொண்டுள்ளது. NumPy-இன் ஒலிபரப்பு பொறிமுறையானது எங்கள் நோக்கத்தைப் புரிந்துகொண்டது. இது scalar `10`-ஐ matrix-இன் `(3, 3)` வடிவத்துடன் பொருந்துமாறு மெய்நிகராக "நீட்டித்தது" அல்லது "ஒலிபரப்பியது", பின்னர் element-wise கூட்டலைச் செய்தது.

முக்கியமாக, இந்த நீட்டிப்பு மெய்நிகரானது. NumPy நினைவகத்தில் 10கள் நிரப்பப்பட்ட ஒரு புதிய 3x3 வரிசையை உருவாக்குவதில்லை. இது C-நிலை செயலாக்கத்தில் நிகழ்த்தப்படும் ஒரு திறமையான செயல்முறையாகும், இது ஒற்றை scalar மதிப்பை மீண்டும் பயன்படுத்துகிறது, இதனால் குறிப்பிடத்தக்க நினைவகம் மற்றும் கணக்கீட்டு நேரத்தை மிச்சப்படுத்துகிறது. இது ஒலிபரப்பின் சாரம்: வெவ்வேறு வடிவங்களைக் கொண்ட வரிசைகளில் அவை இணக்கமானவை போல செயல்பாடுகளைச் செய்வது, அவற்றை உண்மையில் இணக்கமாக்குவதற்கான நினைவகச் செலவு இல்லாமல்.

ஒலிபரப்பு விதிகள்: மர்ம நீக்கம்

ஒலிபரப்பு மாயாஜாலமாகத் தோன்றலாம், ஆனால் அது இரண்டு எளிய, கடுமையான விதிகளால் நிர்வகிக்கப்படுகிறது. இரண்டு வரிசைகளில் செயல்படும் போது, NumPy அவற்றின் வடிவங்களை வலதுபுறத்தில் இருந்து (பின்புறம்) பரிமாணங்களில் தொடங்கி, element-wise ஒப்பிடுகிறது. ஒலிபரப்பு வெற்றிபெற, ஒவ்வொரு பரிமாண ஒப்பீட்டிற்கும் இந்த இரண்டு விதிகளும் பூர்த்தி செய்யப்பட வேண்டும்.

விதி 1: பரிமாணங்களை சீரமைத்தல்

பரிமாணங்களை ஒப்பிடுவதற்கு முன், NumPy ஆனது இரண்டு வரிசைகளின் வடிவங்களை அவற்றின் trailing பரிமாணங்களால் கருத்தளவில் சீரமைக்கிறது. ஒரு வரிசையில் மற்றதை விட குறைவான பரிமாணங்கள் இருந்தால், அது பெரிய வரிசையின் பரிமாணங்களின் அதே எண்ணிக்கையைக் கொண்டிருக்கும் வரை அதன் இடது பக்கத்தில் அளவு 1 கொண்ட பரிமாணங்களுடன் நிரப்பப்படுகிறது.

உதாரணம்:

• வரிசை A இன் வடிவம் `(5, 4)`
• வரிசை B இன் வடிவம் `(4,)`

NumPy இதை பின்வருவனவற்றிற்கு இடையிலான ஒப்பீடாகப் பார்க்கிறது:

• A இன் வடிவம்: `5 x 4`
• B இன் வடிவம்: ` 4`

B ஆனது குறைவான பரிமாணங்களைக் கொண்டிருப்பதால், இந்த வலதுபுற-சீரமைக்கப்பட்ட ஒப்பீட்டிற்கு இது நிரப்பப்படவில்லை. இருப்பினும், நாம் `(5, 4)` மற்றும் `(5,)` ஐ ஒப்பிட்டிருந்தால், நிலைமை வேறுபட்டிருக்கும் மற்றும் பிழை ஏற்படும், அதை நாம் பின்னர் ஆராய்வோம்.

விதி 2: பரிமாண இணக்கத்தன்மை

சீரமைப்புக்குப் பிறகு, ஒப்பிடப்படும் ஒவ்வொரு பரிமாண ஜோடிக்கும் (வலமிருந்து இடமாக), பின்வரும் நிபந்தனைகளில் ஒன்று உண்மையாக இருக்க வேண்டும்:

1. பரிமாணங்கள் சமமாக இருக்க வேண்டும்.
2. பரிமாணங்களில் ஒன்று 1 ஆக இருக்க வேண்டும்.

இந்த நிபந்தனைகள் அனைத்து பரிமாண ஜோடிகளுக்கும் பொருந்தினால், வரிசைகள் "ஒலிபரப்பு-இணக்கமானவை" என்று கருதப்படுகின்றன. இதன் விளைவாக வரும் வரிசையின் வடிவம், உள்ளீட்டு வரிசைகளின் பரிமாணங்களின் அதிகபட்ச அளவைக் கொண்ட ஒவ்வொரு பரிமாணத்திற்கும் ஒரு அளவைக் கொண்டிருக்கும்.

எந்த ஒரு கட்டத்திலும் இந்த நிபந்தனைகள் பூர்த்தி செய்யப்படாவிட்டால், NumPy கைவிட்டு, "`operands could not be broadcast together with shapes ...`" போன்ற தெளிவான செய்தியுடன் ஒரு `ValueError`-ஐ எழுப்புகிறது.

நடைமுறை உதாரணங்கள்: ஒலிபரப்பு செயல்பாட்டில்

எளிமையானது முதல் சிக்கலானது வரையிலான தொடர்ச்சியான நடைமுறை உதாரணங்களுடன் இந்த விதிகளைப் பற்றிய நமது புரிதலை உறுதிப்படுத்துவோம்.

உதாரணம் 1: எளிமையான நிலை - Scalar மற்றும் வரிசை

இது நாம் தொடங்கிய உதாரணம். நமது விதிகளின் கண்ணோட்டத்தில் இதை பகுப்பாய்வு செய்வோம்.

A = np.array([[1, 2, 3], [4, 5, 6]]) # வடிவம்: (2, 3) B = 10 # வடிவம்: () C = A + B

பகுப்பாய்வு:

1. வடிவங்கள்: A என்பது `(2, 3)`, B என்பது திறம்பட ஒரு scalar.
2. விதி 1 (சீரமைத்தல்): NumPy scalar-ஐ எந்த இணக்கமான பரிமாணத்தின் வரிசையாகவும் கருதுகிறது. அதன் வடிவம் `(1, 1)` ஆக நிரப்பப்படுவதாக நாம் கருதலாம். `(2, 3)` மற்றும் `(1, 1)` ஐ ஒப்பிடுவோம்.
3. விதி 2 (இணக்கத்தன்மை):
   • Trailing பரிமாணம்: `3` vs `1`. நிபந்தனை 2 பூர்த்தி செய்யப்படுகிறது (ஒன்று 1).
   • அடுத்த பரிமாணம்: `2` vs `1`. நிபந்தனை 2 பூர்த்தி செய்யப்படுகிறது (ஒன்று 1).
4. முடிவு வடிவம்: ஒவ்வொரு பரிமாண ஜோடியின் அதிகபட்சம் `(max(2, 1), max(3, 1))`, இது `(2, 3)` ஆகும். scalar `10` இந்த முழு வடிவத்திலும் ஒலிபரப்பப்படுகிறது.

உதாரணம் 2: 2D வரிசை மற்றும் 1D வரிசை (அணி மற்றும் வெக்டர்)

இது மிகவும் பொதுவான பயன்பாட்டு நிகழ்வு ஆகும், அதாவது ஒரு தரவு அணிக்கு feature-wise offset-ஐச் சேர்ப்பது.

A = np.arange(12).reshape(3, 4) # வடிவம்: (3, 4) # A = array([[ 0, 1, 2, 3], # [ 4, 5, 6, 7], # [ 8, 9, 10, 11]]) B = np.array([10, 20, 30, 40]) # வடிவம்: (4,) C = A + B

பகுப்பாய்வு:

1. வடிவங்கள்: A என்பது `(3, 4)`, B என்பது `(4,)`.
2. விதி 1 (சீரமைத்தல்): வடிவங்களை வலதுபுறமாக சீரமைக்கிறோம்.
   • A இன் வடிவம்: `3 x 4`
   • B இன் வடிவம்: ` 4`
3. விதி 2 (இணக்கத்தன்மை):
   • Trailing பரிமாணம்: `4` vs `4`. நிபந்தனை 1 பூர்த்தி செய்யப்படுகிறது (அவை சமம்).
   • அடுத்த பரிமாணம்: `3` vs `(ஏதுமில்லை)`. சிறிய வரிசையில் ஒரு பரிமாணம் இல்லாதபோது, அந்த பரிமாணத்தின் அளவு 1 ஆக இருப்பது போல் இருக்கும். எனவே நாம் `3` vs `1` ஐ ஒப்பிடுகிறோம். நிபந்தனை 2 பூர்த்தி செய்யப்படுகிறது. B இலிருந்து வரும் மதிப்பு இந்த பரிமாணத்துடன் நீட்டிக்கப்படுகிறது அல்லது ஒலிபரப்பப்படுகிறது.
4. முடிவு வடிவம்: இதன் விளைவாக வரும் வடிவம் `(3, 4)` ஆகும். 1D வரிசை `B` ஆனது ஒவ்வொரு வரிசையுடனும் `A`-இன் திறம்பட சேர்க்கப்படுகிறது.

   # C இவ்வாறாக இருக்கும்: # array([[10, 21, 32, 43], # [14, 25, 36, 47], # [18, 29, 40, 51]])

உதாரணம் 3: Column மற்றும் Row வெக்டர் சேர்க்கை

ஒரு column vector-ஐ ஒரு row vector உடன் இணைக்கும்போது என்ன நடக்கும்? இங்குதான் ஒலிபரப்பு சக்திவாய்ந்த outer-product போன்ற நடத்தைகளை உருவாக்குகிறது.

A = np.array([0, 10, 20]).reshape(3, 1) # வடிவம்: (3, 1) ஒரு column vector # A = array([[ 0], # [10], # [20]]) B = np.array([0, 1, 2]) # வடிவம்: (3,). (1, 3) ஆகவும் இருக்கலாம் # B = array([0, 1, 2]) C = A + B

பகுப்பாய்வு:

1. வடிவங்கள்: A என்பது `(3, 1)`, B என்பது `(3,)`.
2. விதி 1 (சீரமைத்தல்): வடிவங்களை சீரமைக்கிறோம்.
   • A இன் வடிவம்: `3 x 1`
   • B இன் வடிவம்: ` 3`
3. விதி 2 (இணக்கத்தன்மை):
   • Trailing பரிமாணம்: `1` vs `3`. நிபந்தனை 2 பூர்த்தி செய்யப்படுகிறது (ஒன்று 1). வரிசை `A` இந்த பரிமாணம் முழுவதும் நீட்டிக்கப்படும் (columns).
   • அடுத்த பரிமாணம்: `3` vs `(ஏதுமில்லை)`. முன்பு போலவே, இதை `3` vs `1` ஆக கருதுகிறோம். நிபந்தனை 2 பூர்த்தி செய்யப்படுகிறது. வரிசை `B` இந்த பரிமாணம் முழுவதும் நீட்டிக்கப்படும் (rows).
4. முடிவு வடிவம்: ஒவ்வொரு பரிமாண ஜோடியின் அதிகபட்சம் `(max(3, 1), max(1, 3))`, இது `(3, 3)` ஆகும். முடிவு ஒரு முழு matrix ஆகும்.

   # C இவ்வாறாக இருக்கும்: # array([[ 0, 1, 2], # [10, 11, 12], # [20, 21, 22]])

உதாரணம் 4: ஒரு ஒலிபரப்பு தோல்வி (ValueError)

ஒலிபரப்பு எப்போது தோல்வியடையும் என்பதைப் புரிந்துகொள்வது சமமாக முக்கியம். 3x4 matrix-இன் ஒவ்வொரு column-உடனும் நீளம் 3 கொண்ட ஒரு vector-ஐ சேர்க்க முயற்சிப்போம்.

A = np.arange(12).reshape(3, 4) # வடிவம்: (3, 4) B = np.array([10, 20, 30]) # வடிவம்: (3,) try: C = A + B except ValueError as e: print(e)

இந்த குறியீடு அச்சிடும்: operands could not be broadcast together with shapes (3,4) (3,)

பகுப்பாய்வு:

1. வடிவங்கள்: A என்பது `(3, 4)`, B என்பது `(3,)`.
2. விதி 1 (சீரமைத்தல்): வடிவங்களை வலதுபுறமாக சீரமைக்கிறோம்.
   • A இன் வடிவம்: `3 x 4`
   • B இன் வடிவம்: ` 3`
3. விதி 2 (இணக்கத்தன்மை):
   • Trailing பரிமாணம்: `4` vs `3`. இது தோல்வியடைகிறது! பரிமாணங்கள் சமமாக இல்லை, அவற்றில் எதுவும் 1 அல்ல. NumPy உடனடியாக நின்று ஒரு `ValueError`-ஐ எழுப்புகிறது.

இந்தத் தோல்வி தர்க்கரீதியானது. அளவு 3 கொண்ட ஒரு vector-ஐ அளவு 4 கொண்ட rows-உடன் NumPy-இனால் சீரமைக்கத் தெரியவில்லை. எங்கள் நோக்கம் ஒரு *column* vector-ஐச் சேர்ப்பதாக இருக்கலாம். அதைச் செய்ய, வரிசை B இன் வடிவத்தை வெளிப்படையாக கையாள வேண்டும், இது நமது அடுத்த தலைப்பிற்கு நம்மை இட்டுச் செல்கிறது.

ஒலிபரப்பிற்கான வரிசை வடிவ கையாளுதலில் தேர்ச்சி பெறுதல்

பெரும்பாலும், நீங்கள் செய்ய விரும்பும் செயல்பாட்டிற்கு உங்கள் தரவு சரியான வடிவத்தில் இருக்காது. NumPy ஆனது வரிசைகளை மறுவடிவமைக்கவும் மற்றும் கையாளவும் பல கருவிகளை வழங்குகிறது, அவை ஒலிபரப்பு-இணக்கமானதாக மாற்றப்படும். இது ஒலிபரப்பின் தோல்வி அல்ல, மாறாக உங்கள் நோக்கங்களை வெளிப்படையாகக் கூறுவதற்கு உங்களைத் தூண்டும் ஒரு அம்சம்.

`np.newaxis`-இன் சக்தி

ஒரு வரிசையை இணக்கமாக்குவதற்கான பொதுவான கருவி `np.newaxis` ஆகும். இது ஏற்கனவே உள்ள வரிசையின் பரிமாணத்தை 1 அளவுள்ள ஒரு பரிமாணத்தால் அதிகரிக்கப் பயன்படுகிறது. இது `None` என்பதற்கான ஒரு மாற்றுப்பெயர், எனவே நீங்கள் `None`-ஐயும் சுருக்கமான தொடரியலுக்குப் பயன்படுத்தலாம்.

முன்பு தோல்வியடைந்த உதாரணத்தை சரிசெய்வோம். `B` vector-ஐ `A`-இன் ஒவ்வொரு column-உடனும் சேர்ப்பதே எங்கள் நோக்கம். இதன் பொருள் `B` ஆனது `(3, 1)` வடிவத்தின் column vector ஆகக் கருதப்பட வேண்டும்.

A = np.arange(12).reshape(3, 4) # வடிவம்: (3, 4) B = np.array([10, 20, 30]) # வடிவம்: (3,) # ஒரு புதிய பரிமாணத்தைச் சேர்க்க newaxis ஐப் பயன்படுத்தவும், B-ஐ ஒரு column vector ஆக மாற்றவும் B_reshaped = B[:, np.newaxis] # வடிவம் இப்போது (3, 1) # B_reshaped இப்போது இவ்வாறாக இருக்கும்: # array([[10], # [20], # [30]]) C = A + B_reshaped

சரிசெய்யப்பட்ட பகுப்பாய்வு:

1. வடிவங்கள்: A என்பது `(3, 4)`, B_reshaped என்பது `(3, 1)`.
2. விதி 2 (இணக்கத்தன்மை):
   • Trailing பரிமாணம்: `4` vs `1`. சரி (ஒன்று 1).
   • அடுத்த பரிமாணம்: `3` vs `3`. சரி (அவை சமம்).
3. முடிவு வடிவம்: `(3, 4)`. `(3, 1)` column vector ஆனது A-இன் 4 columns முழுவதும் ஒலிபரப்பப்படுகிறது.

   # C இவ்வாறாக இருக்கும்: # array([[10, 11, 12, 13], # [24, 25, 26, 27], # [38, 39, 40, 41]])

`[:, np.newaxis]` தொடரியல் ஆனது 1D வரிசையை ஒரு column vector ஆக மாற்றுவதற்கு NumPy-இல் ஒரு நிலையான மற்றும் மிகவும் வாசிக்கக்கூடிய மரபு ஆகும்.

`reshape()` முறை

ஒரு வரிசையின் வடிவத்தை மாற்றுவதற்கான ஒரு பொதுவான கருவி `reshape()` முறை ஆகும். மொத்த உறுப்புகளின் எண்ணிக்கை மாறாமல் இருக்கும் வரை புதிய வடிவத்தை முழுமையாகக் குறிப்பிட இது உங்களை அனுமதிக்கிறது.

`reshape`-ஐப் பயன்படுத்தி மேலே உள்ள அதே முடிவை நாம் பெற்றிருக்கலாம்:

B_reshaped = B.reshape(3, 1) # B[:, np.newaxis] போலவே

`reshape()` முறை மிகவும் சக்தி வாய்ந்தது, குறிப்பாக அதன் சிறப்பு `-1` வாதத்துடன், இது வரிசையின் மொத்த அளவு மற்றும் மற்ற குறிப்பிட்ட பரிமாணங்களின் அடிப்படையில் அந்த பரிமாணத்தின் அளவை தானாகவே கணக்கிட NumPy க்குத் தெரிவிக்கிறது.

x = np.arange(12) # 4 வரிசைகளாக மறுவடிவமைக்கவும், மற்றும் column-களின் எண்ணிக்கையை தானாகவே கணக்கிடவும் x_reshaped = x.reshape(4, -1) # வடிவம் (4, 3) ஆக இருக்கும்

`.T` உடன் மாற்றுதல்

ஒரு வரிசையை மாற்றுவது அதன் அச்சுகளை இடமாற்றுகிறது. ஒரு 2D வரிசைக்கு, இது rows மற்றும் columns-ஐ புரட்டுகிறது. இது ஒலிபரப்பு செயல்பாட்டிற்கு முன் வடிவங்களை சீரமைக்க மற்றொரு பயனுள்ள கருவியாக இருக்கலாம்.

A = np.arange(12).reshape(3, 4) # வடிவம்: (3, 4) A_transposed = A.T # வடிவம்: (4, 3)

எங்கள் குறிப்பிட்ட ஒலிபரப்பு பிழையை சரிசெய்வதற்கு நேரடியாகக் குறைவாக இருந்தாலும், மாற்றுதலைப் புரிந்துகொள்வது பொதுவான matrix கையாளுதலுக்கு முக்கியமானது, இது பெரும்பாலும் ஒலிபரப்பு செயல்பாடுகளுக்கு முன் நிகழ்கிறது.

மேம்பட்ட ஒலிபரப்பு பயன்பாடுகள் மற்றும் பயன்பாட்டுச் சூழல்கள்

இப்போது நாம் விதிகள் மற்றும் கருவிகளைப் பற்றிய உறுதியான புரிதலைப் பெற்றிருப்பதால், ஒலிபரப்பு நேர்த்தியான மற்றும் திறமையான தீர்வுகளை செயல்படுத்தும் சில நிஜ-உலக சூழ்நிலைகளை ஆராய்வோம்.

1. தரவு இயல்பாக்கம் (Standardization)

இயந்திரக் கற்றலில் ஒரு அடிப்படை preprocessing படி, அம்சங்களை தரப்படுத்துவது ஆகும், பொதுவாக சராசரியைக் கழித்து திட்ட விலக்கத்தால் வகுப்பதன் மூலம் (Z-score இயல்பாக்கம்). ஒலிபரப்பு இதை எளிதாக்குகிறது.

1,000 மாதிரிகள் மற்றும் 5 அம்சங்களைக் கொண்ட ஒரு தரவுத்தொகுப்பு `X` ஐக் கற்பனை செய்து பாருங்கள், அது `(1000, 5)` வடிவத்தைக் கொடுக்கிறது.

# சில மாதிரி தரவை உருவாக்கவும் np.random.seed(0) X = np.random.rand(1000, 5) * 100 # ஒவ்வொரு feature-இன் (column) சராசரி மற்றும் திட்ட விலக்கைக் கணக்கிடுங்கள் # axis=0 என்பது columns முழுவதும் செயல்பாட்டைச் செய்கிறோம் என்பதைக் குறிக்கிறது mean = X.mean(axis=0) # வடிவம்: (5,) std = X.std(axis=0) # வடிவம்: (5,) # இப்போது, ஒலிபரப்பைப் பயன்படுத்தி தரவை இயல்பாக்கவும் X_normalized = (X - mean) / std

பகுப்பாய்வு:

• `X - mean`-இல், நாம் `(1000, 5)` மற்றும் `(5,)` வடிவங்களில் செயல்படுகிறோம்.
• இது நமது உதாரணம் 2 போலவே உள்ளது. `(5,)` வடிவத்தின் `mean` vector ஆனது `X`-இன் 1000 rows முழுவதும் ஒலிபரப்பப்படுகிறது.
• `std`-ஆல் வகுப்பதற்கும் அதே ஒலிபரப்பு நிகழ்கிறது.

ஒலிபரப்பு இல்லாமல், நீங்கள் ஒரு சுழற்சியை எழுத வேண்டும், இது பல மடங்கு மெதுவாகவும் மற்றும் வார்த்தை ஜாலமாகவும் இருக்கும்.

2. வரைதல் மற்றும் கணக்கீட்டிற்கான Grids உருவாக்குதல்

heatmap அல்லது contour plot போன்ற 2D grid புள்ளிகளில் ஒரு செயல்பாட்டை மதிப்பிட விரும்பினால், ஒலிபரப்பு சரியான கருவியாகும். இதற்காக `np.meshgrid` பெரும்பாலும் பயன்படுத்தப்பட்டாலும், அடிப்படை ஒலிபரப்பு பொறிமுறையைப் புரிந்துகொள்ள அதே முடிவை கைமுறையாகவும் பெறலாம்.

# x மற்றும் y அச்சுகளுக்கான 1D வரிசைகளை உருவாக்கவும் x = np.linspace(-5, 5, 11) # வடிவம் (11,) y = np.linspace(-4, 4, 9) # வடிவம் (9,) # ஒலிபரப்பிற்காக அவற்றை தயார்படுத்த newaxis ஐப் பயன்படுத்தவும் x_grid = x[np.newaxis, :] # வடிவம் (1, 11) y_grid = y[:, np.newaxis] # வடிவம் (9, 1) # மதிப்பிடுவதற்கான ஒரு செயல்பாடு, எ.கா., f(x, y) = x^2 + y^2 # ஒலிபரப்பு முழு 2D முடிவு grid-ஐ உருவாக்குகிறது z = x_grid**2 + y_grid**2 # இதன் விளைவாக வரும் வடிவம்: (9, 11)

பகுப்பாய்வு:

• நாம் `(1, 11)` வடிவத்தின் வரிசையை `(9, 1)` வடிவத்தின் வரிசையுடன் சேர்க்கிறோம்.
• விதிகளின்படி, `x_grid` 9 rows முழுவதும் ஒலிபரப்பப்படுகிறது, மேலும் `y_grid` 11 columns முழுவதும் ஒலிபரப்பப்படுகிறது.
• முடிவு என்பது ஒவ்வொரு `(x, y)` ஜோடியிலும் மதிப்பிடப்பட்ட செயல்பாட்டைக் கொண்ட `(9, 11)` grid ஆகும்.

3. ஜோடி தூர அணி (Pairwise Distance Matrices) கணக்கிடுதல்

இது ஒரு மேம்பட்ட ஆனால் நம்பமுடியாத சக்திவாய்ந்த உதாரணம். ஒரு `D`-பரிமாண இடத்தில் `N` புள்ளிகளைக் கொண்ட ஒரு தொகுப்பு (`(N, D)` வடிவத்தின் ஒரு வரிசை) கொடுக்கப்பட்டால், ஒவ்வொரு புள்ளி ஜோடிக்கு இடையேயான தூரங்களின் `(N, N)` matrix-ஐ எவ்வாறு திறமையாக கணக்கிடலாம்?

ஒரு 3D ஒலிபரப்பு செயல்பாட்டை அமைக்க `np.newaxis` ஐப் பயன்படுத்துவதே முக்கிய தந்திரமாகும்.

# 2-பரிமாண இடத்தில் 5 புள்ளிகள் np.random.seed(42) points = np.random.rand(5, 2) # ஒலிபரப்பிற்காக வரிசைகளை தயார்படுத்தவும் # points ஐ (5, 1, 2) ஆக மறுவடிவமைக்கவும் P1 = points[:, np.newaxis, :] # points ஐ (1, 5, 2) ஆக மறுவடிவமைக்கவும் P2 = points[np.newaxis, :, :] # P1 - P2 ஒலிபரப்பின் வடிவங்கள் இவ்வாறாக இருக்கும்: # (5, 1, 2) # (1, 5, 2) # இதன் விளைவாக வரும் வடிவம் (5, 5, 2) ஆக இருக்கும் diff = P1 - P2 # இப்போது squared Euclidean தூரத்தைக் கணக்கிடுங்கள் # கடைசி அச்சு (D பரிமாணங்கள்) முழுவதும் சதுரங்களை நாம் சேர்க்கிறோம் dist_sq = np.sum(diff**2, axis=-1) # வர்க்கமூலம் எடுத்து இறுதி தூர matrix-ஐப் பெறுங்கள் distances = np.sqrt(dist_sq) # இறுதி வடிவம்: (5, 5)

இந்த வெக்டராக்கப்பட்ட குறியீடு இரண்டு உள்ளமைக்கப்பட்ட சுழற்சிகளை மாற்றி, பெருமளவு திறமையானது. வரிசை வடிவங்கள் மற்றும் ஒலிபரப்பு அடிப்படையில் சிந்திப்பது சிக்கலான சிக்கல்களை எவ்வாறு நேர்த்தியாக தீர்க்க முடியும் என்பதற்கு இது ஒரு சான்றாகும்.

செயல்திறன் தாக்கங்கள்: ஒலிபரப்பு ஏன் முக்கியம்

ஒலிபரப்பு மற்றும் வெக்டராக்கம் பைதான் சுழற்சிகளை விட வேகமாக இருக்கும் என்று நாம் மீண்டும் மீண்டும் கூறியுள்ளோம். ஒரு எளிய சோதனை மூலம் அதை நிரூபிப்போம். ஒருமுறை ஒரு சுழற்சி மூலமாகவும், ஒருமுறை NumPy மூலமாகவும் இரண்டு பெரிய வரிசைகளைச் சேர்ப்போம்.

வெக்டராக்கம் vs. சுழற்சிகள்: ஒரு வேக சோதனை

ஒரு விளக்கத்திற்கு பைத்தானின் உள்ளமைக்கப்பட்ட `time` தொகுதியைப் பயன்படுத்தலாம். ஒரு நிஜ-உலக சூழ்நிலையில் அல்லது Jupyter Notebook போன்ற ஊடாடும் சூழலில், மேலும் கடுமையான அளவீட்டிற்கு `%timeit` magic command ஐப் பயன்படுத்தலாம்.

import time # பெரிய வரிசைகளை உருவாக்கவும் a = np.random.rand(1000, 1000) b = np.random.rand(1000, 1000) # --- முறை 1: பைதான் சுழற்சி --- start_time = time.time() c_loop = np.zeros_like(a) for i in range(a.shape[0]): for j in range(a.shape[1]): c_loop[i, j] = a[i, j] + b[i, j] loop_duration = time.time() - start_time # --- முறை 2: NumPy வெக்டராக்கம் --- start_time = time.time() c_numpy = a + b numpy_duration = time.time() - start_time print(f"பைதான் சுழற்சியின் கால அளவு: {loop_duration:.6f} வினாடிகள்") print(f"NumPy வெக்டராக்கத்தின் கால அளவு: {numpy_duration:.6f} வினாடிகள்") print(f"NumPy தோராயமாக {loop_duration / numpy_duration:.1f} மடங்கு வேகமானது.")

இந்த குறியீட்டை ஒரு பொதுவான கணினியில் இயக்கும்போது, NumPy பதிப்பு 100 முதல் 1000 மடங்கு வேகமானது என்பதைக் காட்டும். வரிசை அளவுகள் அதிகரிக்கும்போது இந்த வேறுபாடு இன்னும் வியத்தகு முறையில் மாறும். இது ஒரு சிறிய optimization அல்ல; இது ஒரு அடிப்படை செயல்திறன் வேறுபாடு.

"உள்ளே என்ன நடக்கிறது" - நன்மை

NumPy ஏன் இவ்வளவு வேகமாக இருக்கிறது? அதன் கட்டமைப்பு காரணமாகவே:

• தொகுக்கப்பட்ட குறியீடு: NumPy செயல்பாடுகள் பைதான் மொழிபெயர்ப்பாளரால் செயல்படுத்தப்படுவதில்லை. அவை முன்பே தொகுக்கப்பட்ட, மிகவும் மேம்படுத்தப்பட்ட C அல்லது Fortran செயல்பாடுகள். எளிய `a + b` ஒரு ஒற்றை, வேகமான C செயல்பாட்டை அழைக்கிறது.
• நினைவக அமைப்பு: NumPy வரிசைகள் நினைவகத்தில் ஒரு நிலையான தரவு வகையுடன் கூடிய அடர்த்தியான தரவுத் தொகுதிகளாகும். இது பைதான் பட்டியல்களுடன் தொடர்புடைய வகைச் சரிபார்ப்பு மற்றும் பிற overhead இல்லாமல் அடிப்படை C குறியீட்டை அவற்றின் மீது மறு செய்கை செய்ய அனுமதிக்கிறது.
• SIMD (Single Instruction, Multiple Data): நவீன CPUகள் ஒரே நேரத்தில் பல தரவுகளில் ஒரே செயல்பாட்டைச் செய்ய முடியும். NumPy-இன் தொகுக்கப்பட்ட குறியீடு இந்த வெக்டர் செயலாக்க திறன்களைப் பயன்படுத்திக் கொள்ள வடிவமைக்கப்பட்டுள்ளது, இது ஒரு நிலையான பைதான் சுழற்சிக்கு சாத்தியமற்றது.

ஒலிபரப்பு இந்த நன்மைகள் அனைத்தையும் பெறுகிறது. உங்கள் வரிசை வடிவங்கள் சரியாகப் பொருந்தாதபோதும் வெக்டராக்கப்பட்ட C செயல்பாடுகளின் சக்தியை அணுக உங்களை அனுமதிக்கும் ஒரு ஸ்மார்ட் அடுக்கு இது.

பொதுவான ஆபத்துகள் மற்றும் சிறந்த நடைமுறைகள்

சக்தி வாய்ந்ததாக இருந்தாலும், ஒலிபரப்புக்கு கவனம் தேவை. மனதில் கொள்ள வேண்டிய சில பொதுவான சிக்கல்கள் மற்றும் சிறந்த நடைமுறைகள் இங்கே.

மறைமுக ஒலிபரப்பு பிழைகளை மறைக்கலாம்

ஒலிபரப்பு சில சமயங்களில் "வெறுமனே வேலை செய்வதால்", உங்கள் வரிசை வடிவங்களில் கவனமாக இல்லாவிட்டால் நீங்கள் விரும்பாத ஒரு முடிவை உருவாக்கலாம். உதாரணமாக, ஒரு `(3,)` வரிசையை ஒரு `(3, 3)` matrix உடன் சேர்ப்பது வேலை செய்கிறது, ஆனால் ஒரு `(4,)` வரிசையைச் சேர்ப்பது தோல்வியடைகிறது. நீங்கள் தற்செயலாக தவறான அளவுள்ள ஒரு vector-ஐ உருவாக்கினால், ஒலிபரப்பு உங்களைக் காப்பாற்றாது; அது சரியாக ஒரு பிழையை எழுப்பும். row vs. column vector குழப்பத்திலிருந்து மேலும் நுட்பமான பிழைகள் வருகின்றன.

வடிவங்களில் வெளிப்படையாக இருங்கள்

பிழைகளைத் தவிர்க்கவும் மற்றும் குறியீட்டு தெளிவை மேம்படுத்தவும், வெளிப்படையாக இருப்பது பெரும்பாலும் நல்லது. நீங்கள் ஒரு column vector-ஐச் சேர்க்க விரும்பினால், அதன் வடிவத்தை `(N, 1)` ஆக மாற்ற `reshape` அல்லது `np.newaxis` ஐப் பயன்படுத்தவும். இது உங்கள் குறியீட்டை மற்றவர்களுக்கு (மற்றும் உங்கள் எதிர்கால சுயத்திற்கு) மேலும் வாசிக்கக்கூடியதாக ஆக்குகிறது மற்றும் உங்கள் நோக்கங்கள் NumPy க்கு தெளிவாக இருப்பதை உறுதி செய்கிறது.

நினைவகக் கருத்தாய்வுகள்

ஒலிபரப்பு தன்னைத்தானே நினைவக-திறமையானதாக இருந்தாலும் (இடைநிலை நகல்கள் எதுவும் செய்யப்படவில்லை), செயல்பாட்டின் முடிவு மிகப்பெரிய ஒலிபரப்பு வடிவத்துடன் கூடிய ஒரு புதிய வரிசையாகும் என்பதை நினைவில் கொள்ளுங்கள். நீங்கள் ஒரு `(10000, 1)` வரிசையை ஒரு `(1, 10000)` வரிசையுடன் ஒலிபரப்பினால், முடிவு ஒரு `(10000, 10000)` வரிசையாக இருக்கும், இது கணிசமான அளவு நினைவகத்தை பயன்படுத்தலாம். வெளியீட்டு வரிசையின் வடிவத்தைப் பற்றி எப்போதும் அறிந்திருங்கள்.

சிறந்த நடைமுறைகளின் சுருக்கம்

• விதிகளை அறியவும்: ஒலிபரப்பின் இரண்டு விதிகளை உள்வாங்கவும். சந்தேகம் இருந்தால், வடிவங்களை எழுதி கைமுறையாகச் சரிபார்க்கவும்.
• வடிவங்களை அடிக்கடி சரிபார்க்கவும்: வளர்ச்சி மற்றும் பிழைத்திருத்தத்தின் போது `array.shape`-ஐ தாராளமாகப் பயன்படுத்தவும், உங்கள் வரிசைகள் நீங்கள் எதிர்பார்த்த பரிமாணங்களைக் கொண்டுள்ளன என்பதை உறுதிப்படுத்தவும்.
• வெளிப்படையாக இருங்கள்: உங்கள் நோக்கத்தை தெளிவுபடுத்த `np.newaxis` மற்றும் `reshape`-ஐப் பயன்படுத்தவும், குறிப்பாக rows அல்லது columns ஆக விளக்கப்படக்கூடிய 1D vectors-ஐ கையாளும் போது.
• `ValueError`-ஐ நம்புங்கள்: NumPy operands ஒலிபரப்ப முடியாது என்று கூறினால், விதிகள் மீறப்பட்டதால்தான். அதனுடன் சண்டையிடாதீர்கள்; வடிவங்களை பகுப்பாய்வு செய்து, உங்கள் நோக்கத்துடன் பொருந்த உங்கள் வரிசைகளை மறுவடிவமைக்கவும்.

முடிவுரை

NumPy ஒலிபரப்பு என்பது ஒரு வசதியை விட மேலானது; இது பைத்தானில் திறமையான எண் நிரலாக்கத்தின் ஒரு மூலக்கல்லாகும். இது NumPy பாணியை வரையறுக்கும் சுத்தமான, வாசிக்கக்கூடிய மற்றும் மின்னல் வேகமான வெக்டராக்கப்பட்ட குறியீட்டை செயல்படுத்துவதற்கான இயந்திரமாகும்.

பொருந்தாத வரிசைகளில் செயல்படும் அடிப்படை கருத்து முதல் இணக்கத்தன்மையை நிர்வகிக்கும் கடுமையான விதிகள் வரை, மற்றும் `np.newaxis` மற்றும் `reshape` உடன் வடிவ கையாளுதலின் நடைமுறை உதாரணங்கள் மூலம் நாம் பயணம் செய்துள்ளோம். இயல்பாக்கம் மற்றும் தூரக் கணக்கீடுகள் போன்ற நிஜ-உலக தரவு அறிவியல் பணிகளுக்கு இந்த கொள்கைகள் எவ்வாறு பொருந்தும் என்பதை நாம் பார்த்தோம், மேலும் பாரம்பரிய சுழற்சிகளை விட மிகப்பெரிய செயல்திறன் நன்மைகளை நிரூபித்துள்ளோம்.

element-by-element சிந்தனையில் இருந்து முழு-வரிசை செயல்பாடுகளுக்கு மாறுவதன் மூலம், நீங்கள் NumPy-இன் உண்மையான சக்தியை வெளிக்கொணர்கிறீர்கள். ஒலிபரப்பை ஏற்றுக்கொள்ளுங்கள், வடிவங்கள் அடிப்படையில் சிந்தியுங்கள், மேலும் நீங்கள் பைத்தானில் மேலும் திறமையான, மேலும் தொழில்முறை மற்றும் மேலும் சக்திவாய்ந்த அறிவியல் மற்றும் தரவு சார்ந்த பயன்பாடுகளை எழுதுவீர்கள்.